Shareware Grab Bag/Shareware Grab Bag.iso/007/floatpak.arc/FLOATPAK.TXT

Text File | 1988-09-18 | 21KB | 964 lines

/*
** Floating-point library package.
** R.E. Grehan - BYTE Magazine
**
** What you've got here is a floating-point four-banger for the
** 8088/80286/80386 family.  The routines perform:
** fpadd -- addition
** fpmult - multiplication
** fpsub -- subtraction
** fpdiv -- division
** fpinput - input (converts string to floating-point)
** fpoutput - output (converts floating-point to string)
**
** This is not an "industrial strength" package, at least
** not in terms of optimization (although I have unwound
** a lot of loops).
** The C interface routines are written (of course) for BYTE
** Small C -- you should be able to use them as interfacing
** guides for the actual assembly-language floating-point
** routines.
** In the input and output routines, I've added comments in
** spots where the code could be modified to allow for freer
** formats (like, no preceding '+' sign, for example).
** See my articles in the September and October 1988 BYTEs
** for more details.
** Enjoy.
** --Rick Grehan
**
** REFERENCES:
** Microprocessor Programming for Computer Hobbyists by Neill Graham
** Tab books, 1977
**
** Scelbi 8080 Software Gourmet Guide and Cook Book by Robert Findley
** Scelbi Computer Consulting, 1976
*/

/*
** Add two floating-point numbers.
** flt1, flt2, and flt3 are 10-byte arrays holding floating-point
** numbers.
** This function performs: flt1+flt2 --> flt3.
** The function returns 0 if ok, else error code.
*/
fpadd(flt1,flt2,flt3)
char flt1[10], flt2[10], flt3[10];
{
#asm
    MOV    BP,SP
;First move flt1 and flt2 into FAC1 and FAC2
    MOV    SI,6[BP]
    MOV    DI,OFFSET FAC1_SIGN
    CALL    LDFACC
    MOV    SI,4[BP]
    MOV    DI,OFFSET FAC2_SIGN
    CALL    LDFACC
;Perform the addition
    CALL    FPADD
;Make sure everything was ok.
    OR    BX,BX
    JZ    _FPADD1
    XOR    CX,CX        ;For small C
    RET
;Return the result
_FPADD1:
    MOV    DI,2[BP]
    CALL    STFAC1
    XOR    CX,CX        ;For small C
#endasm
}

/*
** Multiply two floating-point numbers.
** flt1, flt2, and flt3 are 10-byte arrays holding floating-point
** numbers.
** This function performs: flt1*flt2 --> flt3.
** The function returns 0 if ok, else error code.
*/
fpmult(flt1,flt2,flt3)
char flt1[10], flt2[10], flt3[10];
{
#asm
    MOV    BP,SP
;First move flt1 and flt2 into FAC1 and FAC2
    MOV    SI,6[BP]
    MOV    DI,OFFSET FAC1_SIGN
    CALL    LDFACC
    MOV    SI,4[BP]
    MOV    DI,OFFSET FAC2_SIGN
    CALL    LDFACC
;Perform the multiplication
    CALL    FPMULT
;Make sure everything was ok.
    OR    BX,BX
    JZ    _FPMUL1
    XOR    CX,CX        ;For small C
    RET
;Return the result
_FPMUL1:
    MOV    DI,2[BP]
    CALL    STFAC1
    XOR    CX,CX        ;For small C
#endasm
}


/*
** Subtract two floating-point numbers.
** flt1, flt2, and flt3 are 10-byte arrays holding floating-point
** numbers.
** This function performs: flt1-flt2 --> flt3.
** The function returns 0 if ok, else error code.
*/
fpsub(flt1,flt2,flt3)
char flt1[10], flt2[10], flt3[10];
{
#asm
    MOV    BP,SP
;First move flt1 and flt2 into FAC1 and FAC2
    MOV    SI,6[BP]
    MOV    DI,OFFSET FAC1_SIGN
    CALL    LDFACC
    MOV    SI,4[BP]
    MOV    DI,OFFSET FAC2_SIGN
    CALL    LDFACC
;Perform the subtraction
    CALL    FPSUB
;Make sure everything was ok.
    OR    BX,BX
    JZ    _FPSUB1
    XOR    CX,CX        ;For small c
    RET
;Return the result
_FPSUB1:
    MOV    DI,2[BP]
    CALL    STFAC1
    XOR    CX,CX        ;For small c
#endasm
}

/*
** Divide floating-point numbers.
** flt1, flt2, and flt3 are 10-byte arrays holding floating-point
** numbers.
** This function performs: flt1/flt2 --> flt3.
** The function returns 0 if ok, else error code.
*/
fpdiv(flt1,flt2,flt3)
char flt1[10], flt2[10], flt3[10];
{
#asm
    MOV    BP,SP
;First move flt1 and flt2 into FAC1 and FAC2
    MOV    SI,6[BP]
    MOV    DI,OFFSET FAC1_SIGN
    CALL    LDFACC
    MOV    SI,4[BP]
    MOV    DI,OFFSET FAC2_SIGN
    CALL    LDFACC
;Perform the division
    CALL    FPDIV
;Make sure everything was ok.
    OR    BX,BX
    JZ    _FPDIV1
    XOR    CX,CX        ;For small c
    RET
;Return the result
_FPDIV1:
    MOV    DI,2[BP]
    CALL    STFAC1
    XOR    CX,CX        ;For small c
#endasm
}

/*
** Input a floating-point number.
** Accepts pointer to a string that must be in the
** form: sd.ddddEsdd<null>
** Also accepts pointer to an array of 10 bytes, into which
** the floating-point number is stored.
*/
fpinput(str,fnum)
char *str;
char fnum[10];
{
#asm
    MOV    BP,SP
;Put pointer to string in SI and call conversion routine
    MOV    SI,4[BP]
    CALL    FPINP
;Move the result into fnum
    MOV    DI,2[BP]
    CALL    STFAC1
    XOR    CX,CX        ;For small c
#endasm
}

/*
** Output a floating-point number.
** Accepts pointer to a 10-byte array containing an floating-
** point number.  Also accepts pointer to a buffer, into
** which the number is stored in the format:
**  sd.ddddEsdd<null>
** Number of digits to the right of the decimal place is
** specified in n.
*/
fpoutput(fnum,buff,n)
char fnum[10];
char *buff;
int n;
{
#asm
    MOV    BP,SP
;First move the number into FAC1
    MOV    SI,6[BP]
    MOV    DI,OFFSET FAC1_SIGN
    CALL    LDFACC
;Do output
    MOV    CX,2[BP]
    MOV    DI,4[BP]
    CALL    FPOUT
    XOR    CX,CX        ;For small c
#endasm
}

/*
** Actual floating-point routines follow.
*/

#asm

;
; Definitions for the floating-point accumulators
;
FAC1_SIGN DB ?  ;FP ACCUM1 - SIGN (80h=negative, 0=positive)
FAC1_EXP DW ?          ;  - EXPONENT
FAC1_MAN DW 5 DUP (?)  ;  - MANTISSA

FAC2_SIGN DB ?        ;Accumulator 2
FAC2_EXP DW ?
FAC2_MAN DW 5 DUP (?)

;Third accumulator for mantissa only - used as a temp location for
;calculations.
FAC3_MAN DW 5 DUP (?)

EXP_SIGN DB    ?    ;Sign of decimal exponent

;Equates
BIAS    EQU    16384    ;Bias for exponent
MAXEXP    EQU    32768    ;Maximum exponent
;Error codes returned
DIVZER    EQU    1    ;Divide by zero error
EXPOVF    EQU    2    ;Exponent overflow error
EXPUND    EQU    3    ;Exponent underflow error



;**********
;Load a floating-point accumulator.
;Assumes SI points to a floating-point number and DI points
;to the _SIGN field of the accumulator to load.
    PUBLIC LDFACC
LDFACC:
    CLD        ;Set direction to increment
;Get the sign bit
    MOV    AX,[SI]
    AND    AH,80H
    MOV    [DI],AH
    INC    DI
;Move the rest
    MOV    BX,DI    ;Save destination location
    MOV    CX,5
    REP    MOVSW
    MOV    WORD PTR [DI],0
;Clear sign bit from exponent
    AND    WORD PTR [BX],7FFFH
    INC    BX
    INC    BX
;Shift the mantissa right 1 bit
    SHR    WORD PTR [BX],1
    RCR    WORD PTR 2[BX],1
    RCR    WORD PTR 4[BX],1
    RCR    WORD PTR 6[BX],1
    RCR    WORD PTR 8[BX],1
LDFACC1:
    RET

;**********
;Store FACC1 to the memory location
;pointed to by DI.
;NOTE: THIS ROUTINE MUNGES FAC1 IN THE PROCESS
; OF STORING IT TO MEMORY.  NOT A GOOD IDEA,
; PARTICULARLY IF YOU'RE DOING LOT'S OF BACK-
; TO-BACK COMPUTATIONS AND YOU WANT TO
; OPTIMIZE THINGS.  (I just thought I should
; bring this to your attention.--rg)
    PUBLIC STFAC1
STFAC1:
;Set direction
    CLD
;Shift the mantissa left 1 bit
    SHL    FAC1_MAN+8,1
    RCL    FAC1_MAN+6,1
    RCL    FAC1_MAN+4,1
    RCL    FAC1_MAN+2,1
    RCL    FAC1_MAN,1
;Set the sign bit based on FAC1_SIGN
    CMP    FAC1_SIGN,0
    JNE    STFC1
    AND    FAC1_EXP,7FFFH
    JMP    SHORT STFC2
STFC1:    OR    FAC1_EXP,8000H
STFC2:
;Move it all over
    MOV    SI,OFFSET FAC1_EXP
    MOV    CX,5
    REP    MOVSW
    RET

;**********
;Floating-point add routine
;Arguments assumed to be in FAC1
; and FAC2.  Result in FAC1
    PUBLIC FPADD
FPADD:
;Determine which argument has the
;larger exponent.  Move the number with the
;larger exponent into FAC1 and the number with the
;smaller exponent into FAC2.
    MOV    AX,FAC1_EXP
    CMP    AX,FAC2_EXP
    JAE    FADD1
    MOV    CX,11
    MOV    SI,OFFSET FAC1_SIGN
    MOV    DI,OFFSET FAC2_SIGN
FADD0:    MOV    AL,[SI]
    XCHG    AL,[DI]
    MOV    [SI],AL
    INC    SI
    INC    DI
    LOOP    FADD0
;Now figure out how many bits to
;shift the mantissa of FAC2 in order
;to align the radix point.  If this
;amount is greater than 78, we can
;go home, cause the result is already
;in FAC1.
FADD1:    MOV    AX,FAC1_EXP
    SUB    AX,FAC2_EXP
    CMP    AX,78
    JL    FADD2
    XOR    BX,BX        ;Show all ok.
    RET
;See if the signs of FAC1 and
;FAC2 differ.  If so, negate the
;mantissa of FAC2.
FADD2:    MOV    BL,FAC1_SIGN
    CMP    BL,FAC2_SIGN
    JZ    FADD3
    MOV    BX,OFFSET FAC2_MAN
    CALL    NEGBX
;Now shift FAC2 right by amount
;given in AX (which is the difference in the
;exponent amounts).
FADD3:    MOV    CX,AX
    OR    CX,CX        ;Shift necessary?
    JZ    FADD4A
FADD4:    SHR    FAC2_MAN,1
    RCR    FAC2_MAN+2,1
    RCR    FAC2_MAN+4,1
    RCR    FAC2_MAN+6,1
    RCR    FAC2_MAN+8,1
    LOOP    FADD4
;Add the two mantissas.
FADD4A:
    MOV    AX,FAC2_MAN+8
    ADD    FAC1_MAN+8,AX
    MOV    AX,FAC2_MAN+6
    ADC    FAC1_MAN+6,AX
    MOV    AX,FAC2_MAN+4
    ADC    FAC1_MAN+4,AX
    MOV    AX,FAC2_MAN+2
    ADC    FAC1_MAN+2,AX
    MOV    AX,FAC2_MAN
    ADC    FAC1_MAN,AX
;See if the sign of the two operands
;differ. If so, and if the result
;of the addition was negative, negate
;the FAC1 mantissa and move the sign
;of FAC2 to FAC1.
    MOV    AL,FAC1_SIGN
    CMP    AL,FAC2_SIGN
    JZ    FADD5
    MOV    AX,FAC1_MAN
    OR    AX,AX
    JNS    FADD5
    MOV    BX,OFFSET FAC1_MAN
    CALL    NEGBX
    MOV    AL,FAC2_SIGN
    MOV    FAC1_SIGN,AL
;Now normalize the contents of FAC1
FADD5:    JMP    NORM_FAC1

;**********
;Floating-point subtract.
;Subtract contents of FAC2 from
;FAC1 and leave the result in FAC1.
;
    PUBLIC FPSUB
FPSUB:
;Flip the sign of FAC2
    XOR    FAC2_SIGN,80H
;And do an ADD
    JMP    FPADD

;**********
;Floating-point multiply
;Multiply FAC1 and FAC2 - result in FAC1
    PUBLIC FPMULT
FPMULT:
;First set up the signs of the result.  Do this by
;performing an exclusive-OR on the signs of the operands
    MOV    AL,FAC2_SIGN
    XOR    FAC1_SIGN,AL
;Now calculate the exponent of the result
    MOV    AX,FAC2_EXP
    ADD    AX,FAC1_EXP
    SUB    AX,BIAS+1
    MOV    FAC1_EXP,AX
;Clear FAC3 to hold results
    XOR    AX,AX
    MOV    FAC3_MAN,AX
    MOV    FAC3_MAN+2,AX
    MOV    FAC3_MAN+4,AX
    MOV    FAC3_MAN+6,AX
    MOV    FAC3_MAN+8,AX
;Set up counter
    MOV    CX,79
;Shift FAC1 and result 1 bit to the right.
;If the bit shifted out of FAC1 is a 1, add FAC2
;to the result.
FMUL1:    SHR    FAC3_MAN,1
    RCR    FAC3_MAN+2,1
    RCR    FAC3_MAN+4,1
    RCR    FAC3_MAN+6,1
    RCR    FAC3_MAN+8,1
;
    SHR    FAC1_MAN,1
    RCR    FAC1_MAN+2,1
    RCR    FAC1_MAN+4,1
    RCR    FAC1_MAN+6,1
    RCR    FAC1_MAN+8,1
    JNC    FMUL2
    MOV    AX,FAC2_MAN+8
    ADD    FAC3_MAN+8,AX
    MOV    AX,FAC2_MAN+6
    ADC    FAC3_MAN+6,AX
    MOV    AX,FAC2_MAN+4
    ADC    FAC3_MAN+4,AX
    MOV    AX,FAC2_MAN+2
    ADC    FAC3_MAN+2,AX
    MOV    AX,FAC2_MAN
    ADC    FAC3_MAN,AX
FMUL2:    LOOP    FMUL1
;Move the result into FAC1
FMUL3:    MOV    SI,OFFSET FAC3_MAN
    MOV    DI,OFFSET FAC1_MAN
    MOV    CX,5
    REP    MOVSW
;Exit via the normalization routine
    JMP    NORM_FAC1

;**********
;Floating-point divide
;Divide FAC1 by FAC2 - result in FAC1
    PUBLIC FPDIV
FPDIV:
;Verify that we are not trying to divide by zero.
;Do this by checking the exponent of FAC2.
    MOV    AX,FAC2_EXP
    OR    AX,AX
    JNE    FDIV0
    MOV    BX,DIVZER        ;Indicate error
    RET                ;Go home
;Figure out the sign of the result
FDIV0:    MOV    AL,FAC2_SIGN
    XOR    FAC1_SIGN,AL
;And calculate the resulting exponent
    MOV    AX,FAC1_EXP
    SUB    AX,FAC2_EXP
    ADD    AX,BIAS        ;Fix bias
    MOV    FAC1_EXP,AX
;Now perform the division, using nonrestoring fraction
;division.  First, clear the result.
    XOR    AX,AX
    MOV    FAC3_MAN,AX
    MOV    FAC3_MAN+2,AX
    MOV    FAC3_MAN+4,AX
    MOV    FAC3_MAN+6,AX
    MOV    FAC3_MAN+8,AX
;Do an initial subtraction
    MOV    AX,FAC2_MAN+8
    SUB    FAC1_MAN+8,AX
    MOV    AX,FAC2_MAN+6
    SBB    FAC1_MAN+6,AX
    MOV    AX,FAC2_MAN+4
    SBB    FAC1_MAN+4,AX
    MOV    AX,FAC2_MAN+2
    SBB    FAC1_MAN+2,AX
    MOV    AX,FAC2_MAN
    SBB    FAC1_MAN,AX
;Set up loop count
    MOV    CX,80
FDIV1:
;Shift quotient left
    SHL    FAC3_MAN+8,1
    RCL    FAC3_MAN+6,1
    RCL    FAC3_MAN+4,1
    RCL    FAC3_MAN+2,1
    RCL    FAC3_MAN,1
;Shift dividend left
    SHL    FAC1_MAN+8,1
    RCL    FAC1_MAN+6,1
    RCL    FAC1_MAN+4,1
    RCL    FAC1_MAN+2,1
    RCL    FAC1_MAN,1
;If 1 bit shifted out of dividend (indicating that
; the result of the subtraction was negative,
; restore by adding divisor back in.
    JNC    FDIV2
    MOV    AX,FAC2_MAN+8
    ADD    FAC1_MAN+8,AX
    MOV    AX,FAC2_MAN+6
    ADC    FAC1_MAN+6,AX
    MOV    AX,FAC2_MAN+4
    ADC    FAC1_MAN+4,AX
    MOV    AX,FAC2_MAN+2
    ADC    FAC1_MAN+2,AX
    MOV    AX,FAC2_MAN
    ADC    FAC1_MAN,AX
    JMP    SHORT FDIV3
;If 0 bit shifted out of dividend, continue process, but make
;sure you set a 1 bit in the quotient.
FDIV2:    MOV    AX,FAC2_MAN+8
    SUB    FAC1_MAN+8,AX
    MOV    AX,FAC2_MAN+6
    SBB    FAC1_MAN+6,AX
    MOV    AX,FAC2_MAN+4
    SBB    FAC1_MAN+4,AX
    MOV    AX,FAC2_MAN+2
    SBB    FAC1_MAN+2,AX
    MOV    AX,FAC2_MAN
    SBB    FAC1_MAN,AX
    OR    FAC3_MAN+8,1    ;Set lo bit of quotient to 1
FDIV3:    LOOP    FDIV1
;Move quotient back into FAC1 and normalize
; (borrow the code already in FMUL to do this.)
    JMP    FMUL3

;
;**********
;NORMALIZE FAC1
;Call this at the end of floating-point operations, and
;before you store the floating-point number.
;
    PUBLIC NORM_FAC1
NORM_FAC1:
;If FAC1's mantissa is zero, claer FAC1's exponent and set
;it's sign to 0 to indicate true zero
    MOV    AX,FAC1_MAN
    OR    AX,FAC1_MAN+2
    OR    AX,FAC1_MAN+4
    OR    AX,FAC1_MAN+6
    OR    AX,FAC1_MAN+8
    JNE    NORM0
    MOV    FAC1_SIGN,AL
    MOV    FAC1_EXP,AX
    XOR    BX,BX        ;Show all ok
    RET
;If we have a 1 in highmost bit - shift FAC1 to the right and
;increment exponent
NORM0:    MOV    BX,FAC1_EXP
    TEST    FAC1_MAN,8000H
    JZ    NORM1
    SHR    FAC1_MAN,1
    RCR    FAC1_MAN+2,1
    RCR    FAC1_MAN+4,1
    RCR    FAC1_MAN+6,1
    RCR    FAC1_MAN+8,1
    INC    BX
;
;Shift FAC1 left until we get a 1 in next-to-highmost bit.
;Subtract 1 from FAC1's exponent each time we do a shift.
NORM1:    TEST    FAC1_MAN,4000H
    JNZ    NORM2
    SHL    FAC1_MAN+8,1
    RCL    FAC1_MAN+6,1
    RCL    FAC1_MAN+4,1
    RCL    FAC1_MAN+2,1
    RCL    FAC1_MAN,1
    DEC    BX
    JMP    NORM1
;
NORM2:
    MOV    FAC1_EXP,BX
;Check to see if the exponent overflowed
    CMP    BX,MAXEXP
    JB    NORM3
    MOV    BX,EXPOVF    ;Error code
    RET
;Check to see if the exponent underflowed
NORM3:    OR    BX,BX
    JNE    NORM4
    MOV    BX,EXPUND
    RET
NORM4:    XOR    BX,BX        ;Show all ok
    RET
;
;Routine to negate the mantissa pointed
;to by BX.
NEGBX:
    MOV    CX,5
    STC
NEG1:    NOT    WORD PTR 8[BX]
    ADC    WORD PTR 8[BX],0
    DEC    BX
    DEC    BX
    LOOP    NEG1
    RET

;**********
;FLOATING-POINT INPUT ROUTINE
;Assume SI points to a string containing:
;   sX.XXXXXEsXXn
; Where s= + or -
;  X is 0-9
;  n is null
    PUBLIC FPINP
FPINP:
;First set the direction for increment
    CLD
;Get the sign
    LODSB
    CMP    AL,'+'
    JNE    INP1
    MOV    AL,0
    JMP    SHORT INP2
INP1:    MOV    AL,80h
INP2:    MOV    FAC1_SIGN,AL
;Clear CX to hold accumulated value of decimal exponent
    XOR    CX,CX
;Clear FAC1
    MOV    FAC1_MAN,CX
    MOV    FAC1_MAN+2,CX
    MOV    FAC1_MAN+4,CX
    MOV    FAC1_MAN+6,CX
    MOV    FAC1_MAN+8,CX
;Get the digit to the left of the decimal point and increment
;decimal exponent
    LODSB
    CALL    ADDIGIT
;Skip past the decimal point.
;**NOTE: Add code to verify format here.
    LODSB
;Read digits to the right of the decimal point
INP3:    LODSB
    CMP    AL,'0'
    JL    INP4    ;Jump if not digit (must be 'E')
    CMP    AL,'9'
    JG    INP4    ;Jump if not digit (must be 'E')
    CALL    ADDIGIT
    DEC    CX    ;Decr. decimal accumulator
    JMP    INP3
;Skip past the 'E'.
;**NOTE: Add code to verify format here.
INP4:
;Read in exponent sign.
    LODSB
    CMP    AL,'+'
    JNE    INP5
    MOV    AL,0    ;Must be negative sign
    JMP    SHORT INP6
INP5:    MOV    AL,80H
INP6:    MOV    EXP_SIGN,AL
;Read in exponent digits
    XOR    BX,BX    ;Use as accumulator
    XOR    AX,AX
    MOV    DL,10    ;Multiplier
INP7:    LODSB
    CMP    AL,'0'
    JL    INP8    ;Jump if not digit (must be null)
    CMP    AL,'9'
    JG    INP8    ;Jump if not digit (must be goofup)
    SUB    AL,'0'    ;Make it a true number
    XCHG    BX,AX    ;Accumulated value in AX
    MUL    DL
    ADD    AX,BX    ;Add in digit
    XCHG    BX,AX    ;Accumulated value back in BX
    JMP    INP7
;Fix up the accumulated exponent in BX
INP8:    MOV    AL,EXP_SIGN
    OR    AL,AL
    JNE    INP9
;Exponent sign is positive
    ADD    CX,BX
    JMP    SHORT INP9A
;Exponent sign is negative
INP9:    SUB    CX,BX
;Normalize FAC1
INP9A:    MOV    FAC1_EXP,BIAS+79
    CALL    NORM_FAC1
;Load FAC2 with a floating point 10.0
    XOR    AX,AX
    MOV    FAC2_SIGN,AL
    MOV    FAC2_EXP,BIAS+4
    MOV    FAC2_MAN,5000H
    MOV    FAC2_MAN+2,AX
    MOV    FAC2_MAN+4,AX
    MOV    FAC2_MAN+6,AX
    MOV    FAC2_MAN+8,AX
;Examine the contents of CX (our decimal exponent).  If CX=-n, divide
;FAC1 by 10 n times.  If CX=+n, multiply FAC1 by n.
    MOV    DX,CX
    OR    DX,DX
    JE    INP11        ;Jump if nothing to do.
    JL    INP12
;Multiply
INP10:    CALL    FPMULT
    DEC    DX
    JNE    INP10
INP11:    RET
;Divide
INP12:    NEG    DX
INP13:    CALL    FPDIV
    DEC    DX
    JNE    INP13
    RET
;
ADDIGIT:
    CALL    FAC1_MBY10    ;Multiply mantissa by 10
;add in the digit
    AND    AX,0FH
    ADD    FAC1_MAN+8,AX
    ADC    FAC1_MAN+6,0
    ADC    FAC1_MAN+4,0
    ADC    FAC1_MAN+2,0
    ADC    FAC1_MAN,0
    RET


;**********
;Floating-point output routine
;Stores the number in FAC1 into memory location
;pointed to by DI.  CX contains the number of digits
;to the right of the decimal place to output.
;Number is stored as a string:
;      sd.dddddddEsddd<Null>
; s is + or - and d is a digit.
;Note: the mantissa can hold 19 significant digits.
    PUBLIC FPOUT
FPOUT:
    CLD
    PUSH    CX        ;Save
;First see if we have true zero.  If so we can skip
;a lot.
    CMP    FAC1_EXP,0
    JZ    FOUT3
;Put a floating-point 10 in FAC2.  We'll use it later
    XOR    AX,AX
    MOV    FAC2_SIGN,AL
    MOV    FAC2_MAN+2,AX
    MOV    FAC2_MAN+4,AX
    MOV    FAC2_MAN+6,AX
    MOV    FAC2_MAN+8,AX
    MOV    FAC2_MAN,5000H
    MOV    FAC2_EXP,BIAS+4
;Use DX to hold the decimal exponent
    XOR    DX,DX
;Divide by 10 while FAC1 is >15 (Check for this by watching
;the exponent).  For each division, increment DX by 1.
FOUT1:    CMP    FAC1_EXP,BIAS+4
    JBE    FOUT2
    CALL    FPDIV
    INC    DX
    JMP    FOUT1
;Multiply by 10 while FAC1 is <1.  For each multiplication,
;decrement DX by 1.
FOUT2:    CMP    FAC1_EXP,BIAS+1
    JA    FOUT2A
    CALL    FPMULT
    DEC    DX
    JMP    FOUT2
;If number is greater than or equal to 10, do one more
;division by 10 to get things in line. And don't forget to
;increment DX.
FOUT2A:
    CMP    FAC1_EXP,BIAS+4
    JNE    FOUT3
    CMP    FAC1_MAN,5000H
    JL    FOUT3
    CALL    FPDIV
    INC    DX
;Position binary point between bits 75 and 76 so we can
;isolate the integer portion of the floating point number.
FOUT3:    CMP    FAC1_EXP,BIAS+4
    JNE    FOUT4
    SHL    FAC1_MAN+8,1
    RCL    FAC1_MAN+6,1
    RCL    FAC1_MAN+4,1
    RCL    FAC1_MAN+2,1
    RCL    FAC1_MAN,1
    JMP    SHORT FOUT5
FOUT4:    CMP    FAC1_EXP,BIAS+3
    JGE    FOUT4A
    SHR    FAC1_MAN,1
    RCR    FAC1_MAN+2,1
    RCR    FAC1_MAN+4,1
    RCR    FAC1_MAN+6,1
    RCR    FAC1_MAN+8,1
    INC    FAC1_EXP
    JMP    FOUT4
;Do any rounding here.  (I'm not happy with what I've got here...
;perhaps a better rounding method could be found.)
FOUT4A:
    ADD    FAC1_MAN+8,9
    ADC    FAC1_MAN+6,0
    ADC    FAC1_MAN+4,0
    ADC    FAC1_MAN+2,0
    ADC    FAC1_MAN,0
;Make sure we didn't overflow
    CMP    FAC1_MAN,0A000H
    JB    FOUT5
    XOR    AX,AX
    MOV    FAC1_MAN+8,AX
    MOV    FAC1_MAN+6,AX
    MOV    FAC1_MAN+4,AX
    MOV    FAC1_MAN+2,AX
    MOV    FAC1_MAN,1000H
    INC    DX
;Save the sign
FOUT5:    CMP    FAC1_SIGN,0
    JNE    FOUT5A
    MOV    BYTE PTR [DI],'+'
    JMP    SHORT FOUT5B
FOUT5A:    MOV    BYTE PTR [DI],'-'
FOUT5B:    INC    DI
;Get leftmost digit
    MOV    AL,BYTE PTR FAC1_MAN+1
    SHR    AL,1
    SHR    AL,1
    SHR    AL,1
    SHR    AL,1    ;Digit now in low nibble
    ADD    AL,'0'
    STOSB
;OUTPUT the decimal point
    MOV    AL,'.'
    STOSB
;Output the remaining digits.
    POP    CX        ;Restore saved count
FOUT6:    AND    FAC1_MAN,0FFFH    ;Strip integer portion
    CALL    FAC1_MBY10    ;Multiply by 10
    MOV    AL,BYTE PTR FAC1_MAN+1
    SHR    AL,1        ;Get next integer part
    SHR    AL,1
    SHR    AL,1
    SHR    AL,1
    ADD    AL,'0'
    STOSB
    LOOP    FOUT6
;Get the exponent portion
    MOV    AL,'E'
    STOSB
    OR    DX,DX
    JS    FOUT7
    MOV    AL,'+'
    JMP    SHORT FOUT8
FOUT7:    MOV    AL,'-'
    NEG    DX        ;Absolute value of exp. in DX
FOUT8:    STOSB
;Following routine gets the exponent value.  Note that we use
;division by 10 to strip off digits as remainders.  This means
;the number comes out in right-to-left order...backwards.  So
;we have to 'flip' the number when we're done.
    MOV    AX,DX
    OR    AX,AX        ;0 exponent?
    JZ    FOUT10
    MOV    SI,DI        ;Save location in buffer
    MOV    CX,10
FOUT9:    XOR    DX,DX        ;Clear for division
    DIV    CX
FOUT10:    ADD    DL,'0'        ;Digit in DX
    MOV    [DI],DL
    INC    DI
    OR    AX,AX        ;Done?
    JNE    FOUT9
    MOV    BYTE PTR [DI],0    ;Store null
;Fix the exponent so it reads left-to-right.
    DEC    DI
FOUT11:    CMP    SI,DI        ;Finished flipping?
    JAE    FOUT12
    MOV    AL,[DI]        ;Swap
    XCHG    AL,[SI]
    MOV    [DI],AL
    INC    SI
    DEC    DI
    JMP    FOUT11
;Exit
FOUT12:    RET

;**********
;Multiply contents of FAC1_MAN by 10.
;Do this using the formula: 10*x = 2*x + 8*x and
;the fact that you can multiply by 2 and multiply by
;8 by doing left shifts.
;Note that this only multiplies manissas...not the entire FP number.
FAC1_MBY10:
    PUSH    AX
    SHL    FAC1_MAN+8,1
    RCL    FAC1_MAN+6,1
    RCL    FAC1_MAN+4,1
    RCL    FAC1_MAN+2,1
    RCL    FAC1_MAN,1
;
    MOV    AX,FAC1_MAN
    MOV    FAC3_MAN,AX
    MOV    AX,FAC1_MAN+2
    MOV    FAC3_MAN+2,AX
    MOV    AX,FAC1_MAN+4
    MOV    FAC3_MAN+4,AX
    MOV    AX,FAC1_MAN+6
    MOV    FAC3_MAN+6,AX
    MOV    AX,FAC1_MAN+8
    MOV    FAC3_MAN+8,AX
;
    SHL    FAC1_MAN+8,1
    RCL    FAC1_MAN+6,1
    RCL    FAC1_MAN+4,1
    RCL    FAC1_MAN+2,1
    RCL    FAC1_MAN,1
;
    SHL    FAC1_MAN+8,1
    RCL    FAC1_MAN+6,1
    RCL    FAC1_MAN+4,1
    RCL    FAC1_MAN+2,1
    RCL    FAC1_MAN,1
;
    MOV    AX,FAC3_MAN+8
    ADD    FAC1_MAN+8,AX
    MOV    AX,FAC3_MAN+6
    ADC    FAC1_MAN+6,AX
    MOV    AX,FAC3_MAN+4
    ADC    FAC1_MAN+4,AX
    MOV    AX,FAC3_MAN+2
    ADC    FAC1_MAN+2,AX
    MOV    AX,FAC3_MAN
    ADC    FAC1_MAN,AX
    POP    AX
;
    RET

#endasm